package com.digua.base.util

object CollUtil {

    /**
     * 判断List是否是空
     *
     * @param list
     * @return
     */
    fun isBlank(list: List<*>?): Boolean {
        return list == null || list.isEmpty()
    }

    /**
     * 判断List是否不为空
     *
     * @param list
     * @return
     */
    fun isNotBlank(list: List<*>?): Boolean {
        return !isBlank(list)
    }

    /**
     * 获取元素所在集合的第一个位置
     *
     * @param list
     * @param item
     * @param <T>
     * @return
    </T> */
    fun <T> getIndex(list: List<T>, item: T): Int {
        return if (isBlank(list)) {
            -1
        } else list.indexOf(item)
    }

    /**
     * 获取元素所在集合的最后一个位置
     *
     * @param list
     * @param item
     * @param <T>
     * @return
    </T> */
    fun <T> getLastIndex(list: List<T>, item: T): Int {
        return if (isBlank(list)) {
            -1
        } else list.lastIndexOf(item)
    }

    /**
     * 比较两个List元素是值是否一样
     *
     * @param list1
     * @param list2
     * @return
     */
    fun <T> equals(list1: List<T>?, list2: List<T>?): Boolean {
        if (list1 == null && list2 == null) {
            return true
        }
        return if (list1 == null || list2 == null) {
            false
        } else list1.containsAll(list2) && list2.containsAll(list1)
    }


    /**
     * 获取集合中的指定位置的值
     *
     * @param list
     * @param index
     * @param def   默认值
     * @param <T>
     * @return
    </T> */
    fun <T> getVal(list: List<T>, index: Int, def: T? = null) = if (isBlank(list) || index < 0 || index > list.size - 1) def else list[index]

    /**
     * 去重
     *
     * @param list
     */
    fun <T> distinct(list: List<T?>) = if (isBlank(list)) list else list.distinct()

    /**
     * List中是否包含某个元素
     *
     * @param list
     * @param t
     * @param <T>
     * @return
    </T> */
    fun <T> contains(list: List<T>, t: T?): Boolean {
        return if (isBlank(list) || t == null) {
            false
        } else list.contains(t)
    }

    /**
     * List中是否包含其中的某个元素
     *
     * @param list
     * @param t
     * @param <T>
     * @return
    </T> */
    fun <T> hasContains(list: List<T>, vararg t: T): Boolean {
        if (isBlank(list) || t.isEmpty()) {
            return false
        }
        for (t1 in t) {
            if (list.contains(t1)) {
                return true
            }
        }
        return false
    }

    /**
     * List中是否包含所有的元素
     *
     * @param list
     * @param t
     * @param <T>
     * @return
    </T> */
    fun <T> allContains(list: List<T>, vararg t: T): Boolean {
        return if (isBlank(list) || t.isEmpty()) {
            false
        } else list.containsAll(toList(*t)!!)
    }

    /**
     * 转成List
     *
     * @param t
     * @param <T>
     * @return
    </T> */
    fun <T> toList(vararg t: T): List<T>? {
        val res = ArrayList<T>()
        for (data in t) {
            res.add(data)
        }
        return res
    }

    /**
     * 转成List
     *
     * @param set
     * @param <T>
     * @return
    </T> */
    fun <T> toListBySet(set: Set<T>?): List<T> {
        if (set?.isNotEmpty() == true) {
            return ArrayList(set)
        }
        return ArrayList<T>()
    }

    /**
     * 获取集合数据数量
     *
     * @param list
     * @return
     */
    fun size(list: List<*>?) = list?.size ?: 0

    /**
     * 获取集合数据数量
     *
     * @param map
     * @return
     */
    fun size(map: Map<*, *>?) = map?.size ?: 0

    fun join(list: List<String?>, separater: String?): String? {
        val s = separater ?: ","
        val buffer = StringBuilder("")
        if (isNotBlank(list)) {
            for (i in list.indices) {
                buffer.append(list[i])
                buffer.append(if (i < list.size - 1) s else "")
            }
        }
        return buffer.toString()
    }

    /**
     * 排序
     *
     * @param list
     * @param c
     * @param <T>
    </T> */
    fun <T : Comparable<T>?> sort(list: List<T>, comparator: Comparator<in T>? = Comparator.naturalOrder<T>()): List<T> {
        if (isNotBlank(list)) return list
        return list.let { datas ->
            comparator?.let {
                datas.sortedWith(comparator)
            } ?: datas
        }
    }

}

